Browser Navigation is one of the most important concepts in Selenium WebDriver. It allows automation scripts to open URLs, move backward and forward through browser history, refresh pages, navigate between different web pages, and work with the current browser location.
Selenium WebDriver provides navigation methods through the WebDriver.Navigation interface. The commonly used navigation operations are opening a URL, going back, going forward, and refreshing the current page.
Browser Navigation means controlling the movement of the browser from one web page or URL to another using Selenium WebDriver.
In manual testing, a user can type a URL, click links, press the Back button, press the Forward button, or click Refresh. In Selenium automation, these activities can be controlled programmatically using WebDriver navigation commands.
Common browser navigation operations include:
Launch Browser
↓
Open URL
↓
Perform Action
↓
Navigate to Another Page
↓
Back / Forward / Refresh
↓
Validate URL or Title
↓
Continue Test
↓
Close Browser
Modern web applications contain multiple pages and navigation paths. A Selenium automation script frequently needs to move between these pages to verify complete user workflows.
For example, an e-commerce test may follow this flow:
Home Page
↓
Login Page
↓
Products Page
↓
Product Details
↓
Cart
↓
Checkout
↓
Order Confirmation
Browser navigation allows Selenium to control these transitions and verify that the application behaves correctly.
Selenium provides several important navigation methods.
| Method | Purpose |
|---|---|
driver.get() |
Opens a specified URL. |
driver.navigate().to() |
Navigates to a specified URL. |
driver.navigate().back() |
Moves one step backward in browser history. |
driver.navigate().forward() |
Moves one step forward in browser history. |
driver.navigate().refresh() |
Refreshes the current page. |
driver.getCurrentUrl() |
Returns the current URL. |
driver.getTitle() |
Returns the current page title. |
Selenium's navigation API provides methods for navigating to URLs, moving backward and forward through browser history, and refreshing the current page.
The driver.get() method is the simplest and most commonly used way to navigate to a web page.
driver.get("URL");WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
The URL should normally include a protocol such as http:// or https://.
Another way to navigate to a URL is by using driver.navigate().to().
driver.navigate().to("URL");WebDriver driver = new ChromeDriver();
driver.navigate().to("https://www.google.com");
The driver.navigate().to() method is part of Selenium's navigation API and can be used together with methods such as back(), forward(), and refresh().
| Feature | driver.get() | driver.navigate().to() |
|---|---|---|
| Purpose | Opens a URL | Navigates to a URL |
| Syntax | driver.get(url) |
driver.navigate().to(url) |
| Ease of use | Short and convenient | More explicit navigation API |
| Back | Not directly provided through this method | Available through navigate().back() |
| Forward | Not directly provided through this method | Available through navigate().forward() |
| Refresh | Not directly provided through this method | Available through navigate().refresh() |
In Selenium's Java API, get(String url) is documented as a synonym for navigation to a URL.
The driver.navigate().back() method moves the browser one step backward through its history.
driver.navigate().back();driver.get("https://www.google.com");
driver.get("https://www.selenium.dev");
driver.navigate().back();
After executing back(), the browser attempts to return to the previous page in its history.
The driver.navigate().forward() method moves the browser forward through its navigation history.
driver.navigate().forward();driver.get("https://www.google.com");
driver.get("https://www.selenium.dev");
driver.navigate().back();
driver.navigate().forward();
The forward operation is useful after navigating backward when the browser history contains a forward entry.
The driver.navigate().refresh() method reloads the current page.
driver.navigate().refresh();driver.get("https://www.selenium.dev");
driver.navigate().refresh();
Refreshing can be useful when testing page reload behavior, dynamic content, session behavior, or application state after a reload.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class BrowserNavigationExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
driver.navigate().to("https://www.selenium.dev");
driver.navigate().back();
driver.navigate().forward();
driver.navigate().refresh();
driver.quit();
}
}
Chrome Opens
↓
Google Opens
↓
Selenium Website Opens
↓
Back to Google
↓
Forward to Selenium
↓
Refresh Selenium Page
↓
Browser Closes
Selenium can open multiple URLs sequentially using the same browser session.
driver.get("https://www.google.com");
driver.get("https://www.selenium.dev");
driver.get("https://example.com");
Each navigation changes the current page of the active browser window.
After navigation, the current URL can be obtained using driver.getCurrentUrl().
driver.get("https://www.selenium.dev");
String currentUrl = driver.getCurrentUrl();
System.out.println(currentUrl);
This is useful for validating whether the browser reached the expected location.
String expectedUrl = "https://www.selenium.dev/";
String actualUrl = driver.getCurrentUrl();
if (actualUrl.equals(expectedUrl)) {
System.out.println("URL validation successful");
} else {
System.out.println("URL validation failed");
}
The driver.getTitle() method can be used to retrieve the title of the current page.
driver.get("https://www.selenium.dev");
String title = driver.getTitle();
System.out.println("Page Title: " + title);
Reading the title is useful when validating whether navigation reached the expected page.
Browser history can be represented as a sequence of visited pages.
Page A
↓
Page B
↓
Page C
If the browser is currently on Page C:
driver.navigate().back();moves the browser toward Page B.
driver.navigate().back();moves it toward Page A.
Then:
driver.navigate().forward();moves forward through the available history.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class NavigationHistory {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
driver.get("https://www.selenium.dev");
driver.get("https://example.com");
System.out.println("Current URL: " + driver.getCurrentUrl());
driver.navigate().back();
System.out.println("After Back: " + driver.getCurrentUrl());
driver.navigate().back();
System.out.println("After Second Back: " + driver.getCurrentUrl());
driver.navigate().forward();
System.out.println("After Forward: " + driver.getCurrentUrl());
driver.quit();
}
}
Browser navigation is commonly used to directly open application pages such as login pages.
driver.get("https://example.com/login");After opening the login page, Selenium can locate username and password fields and perform authentication.
driver.get("https://example.com/login");
driver.findElement(By.id("username")).sendKeys("testuser");
driver.findElement(By.id("password")).sendKeys("password");
driver.findElement(By.id("loginButton")).click();
Automation frameworks often navigate directly to specific application pages.
driver.get("https://example.com/dashboard");This can be useful when a test does not need to repeat every preceding navigation step.
A URL may contain a path that identifies a specific resource or application page.
driver.get("https://example.com/products");
driver.get("https://example.com/products/mobile");
driver.get("https://example.com/products/mobile/details");
Each URL represents a different location in the application.
URLs may also contain query parameters.
driver.get("https://example.com/search?q=selenium");Another example is:
driver.get("https://example.com/products?category=mobile&sort=price");Query parameters can be useful when testing search, filtering, sorting, pagination, and other application features.
Instead of hardcoding URLs throughout a test, URLs can be stored in variables.
String baseUrl = "https://example.com";
driver.get(baseUrl);
This approach makes the test easier to maintain.
String baseUrl = "https://example.com";
String loginUrl = baseUrl + "/login";
String dashboardUrl = baseUrl + "/dashboard";
driver.get(loginUrl);
Automation frameworks commonly work with multiple environments such as development, testing, staging, and production.
| Environment | Example URL |
|---|---|
| Development | https://dev.example.com |
| Testing | https://test.example.com |
| Staging | https://staging.example.com |
| Production | https://example.com |
A configuration file can be used to store the base URL.
baseUrl=https://test.example.comThe Java test can then read the value and navigate to it.
String baseUrl = properties.getProperty("baseUrl");
driver.get(baseUrl);
Usually, the correct page must be opened before Selenium attempts to locate elements on that page.
driver.get("https://example.com/login");
driver.findElement(By.id("username"));
driver.findElement(By.id("password"));
If the test is on the wrong page, the expected elements may not be present and Selenium may throw an element-related exception.
A common automation workflow is opening a website and performing a search.
driver.get("https://www.google.com");
driver.findElement(By.name("q"))
.sendKeys("Selenium WebDriver");
driver.findElement(By.name("btnK"))
.click();
The navigation operation establishes the starting point of the test, while element interactions perform actions on the page.
driver.get("https://example.com/login");
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.findElement(By.id("password"))
.sendKeys("password");
driver.findElement(By.id("login"))
.click();
System.out.println(driver.getCurrentUrl());
This workflow can be extended with assertions to verify successful login.
After navigation, the current URL can be compared with an expected URL.
driver.get("https://example.com/login");
String expectedUrl = "https://example.com/login";
String actualUrl = driver.getCurrentUrl();
if (actualUrl.equals(expectedUrl)) {
System.out.println("Correct page opened");
} else {
System.out.println("Incorrect page opened");
}
driver.get("https://www.selenium.dev");
String title = driver.getTitle();
if (title.contains("Selenium")) {
System.out.println("Correct page opened");
}
URL and title validation are common ways to confirm that navigation reached the intended page.
Some websites automatically redirect users from one URL to another.
driver.get("https://example.com");
String finalUrl = driver.getCurrentUrl();
System.out.println("Final URL: " + finalUrl);
The final URL can be checked after navigation to determine where the browser actually landed.
Browser navigation and page readiness are important considerations in automation. Selenium's default page-load strategy waits for the document ready state to become complete, but that does not necessarily mean every dynamic element of a modern application has finished rendering.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
driver.get("https://example.com");
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.id("content"))
);
Explicit waits are especially useful for applications that load content dynamically.
Selenium supports page-load strategies that influence how navigation commands wait for page loading.
| Strategy | Ready State | Description |
|---|---|---|
| normal | complete | Default strategy that waits for the page to reach complete readiness. |
| eager | interactive | Allows navigation to proceed when the DOM is ready while some resources may still load. |
| none | Any | Does not block WebDriver on page loading. |
Selenium can also perform navigation while the browser runs in headless mode.
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless");
WebDriver driver = new ChromeDriver(options);
driver.get("https://www.selenium.dev");
System.out.println(driver.getTitle());
driver.quit();
Headless execution is useful in CI/CD environments where a visible browser window is not required.
The browser window can be maximized before performing navigation or interacting with the application.
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://www.selenium.dev");
Taking screenshots after navigation can help document the state of the application or troubleshoot failed tests.
driver.get("https://www.selenium.dev");
TakesScreenshot screenshot = (TakesScreenshot) driver;
File source = screenshot.getScreenshotAs(OutputType.FILE);
File destination = new File("homepage.png");
Files.copy(
source.toPath(),
destination.toPath(),
StandardCopyOption.REPLACE_EXISTING
);
Browser navigation is frequently used inside TestNG test methods.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class NavigationTest {
WebDriver driver;
@BeforeMethod
public void setUp() {
driver = new ChromeDriver();
}
@Test
public void browserNavigationTest() {
driver.get("https://www.selenium.dev");
System.out.println(driver.getTitle());
driver.navigate().refresh();
}
@AfterMethod
public void tearDown() {
driver.quit();
}
}
In a Page Object Model framework, navigation is generally represented through page classes or reusable methods.
public class LoginPage {
private WebDriver driver;
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void openLoginPage() {
driver.get("https://example.com/login");
}
}
LoginPage loginPage = new LoginPage(driver);
loginPage.openLoginPage();
This approach separates page-specific behavior from the test logic.
Large automation frameworks may create the WebDriver instance through a Browser Factory.
public class DriverFactory {
public static WebDriver createDriver(String browser) {
if (browser.equalsIgnoreCase("chrome")) {
return new ChromeDriver();
}
if (browser.equalsIgnoreCase("edge")) {
return new EdgeDriver();
}
if (browser.equalsIgnoreCase("firefox")) {
return new FirefoxDriver();
}
throw new IllegalArgumentException("Unsupported browser");
}
}
The test can then use the returned driver for navigation.
WebDriver driver = DriverFactory.createDriver("chrome");
driver.get("https://example.com");
The same navigation logic can generally be used with different browser drivers.
| Browser | Driver |
|---|---|
| Google Chrome | ChromeDriver |
| Mozilla Firefox | FirefoxDriver |
| Microsoft Edge | EdgeDriver |
| Safari | SafariDriver |
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
WebDriver driver = new FirefoxDriver();
driver.get("https://example.com");
WebDriver driver = new EdgeDriver();
driver.get("https://example.com");
Selenium 4 continues to provide the traditional WebDriver navigation API while also supporting newer browser and WebDriver capabilities. Selenium's navigation API provides operations such as navigating to a URL, going backward, going forward, and refreshing.
Navigation can also occur across multiple browser windows or tabs. When multiple browsing contexts exist, Selenium needs to switch to the appropriate window before interacting with it.
String mainWindow = driver.getWindowHandle();
driver.switchTo().newWindow(WindowType.TAB);
driver.get("https://example.com");
driver.switchTo().window(mainWindow);
The WebDriver API provides window and browsing-context mechanisms for working with multiple browser contexts.
Frames and iframes create separate browsing contexts inside a page. Selenium provides switchTo() methods for changing focus to a frame.
driver.get("https://example.com");
driver.switchTo().frame("frameName");
driver.findElement(By.id("element")).click();
driver.switchTo().defaultContent();
The important concept is that normal URL navigation and frame switching are different operations.
| Navigation Using URL | Navigation Using Link |
|---|---|
driver.get(url) |
element.click() |
| Directly opens a URL. | Performs a user-like click on a link or button. |
| Useful when a test already knows the destination. | Useful for testing the actual link behavior. |
| Does not test whether a visible link points to the expected destination. | Can test the application's navigation flow. |
driver.get("https://example.com/products");driver.findElement(By.linkText("Products")).click();Navigation should usually be followed by a validation step in an automated test.
driver.get("https://example.com/login");
Assert.assertEquals(
driver.getCurrentUrl(),
"https://example.com/login"
);
Assert.assertTrue(
driver.getTitle().contains("Login")
);
Assertions help turn navigation into a testable verification rather than merely opening a page.
A URL without a proper protocol can cause navigation problems.
Incorrect:
driver.get("example.com");Correct:
driver.get("https://example.com");If the browser driver cannot be created or communicated with correctly, navigation cannot begin.
The test may open an incorrect application environment or incorrect path.
Dynamic applications may require explicit waits for specific elements.
The application may redirect the browser to another URL.
If the test is currently focused on another tab or window, navigation may occur in that context instead of the intended one.
https:// or http:// in the URL.driver.get() for simple direct navigation.navigate() methods when browser-history operations are required.Consider an online shopping application.
Open Application
↓
Home Page
↓
Login Page
↓
Enter Credentials
↓
Dashboard
↓
Products
↓
Product Details
↓
Add to Cart
↓
Checkout
↓
Order Confirmation
At each important transition, Selenium can validate the URL, title, page content, or a specific element.
import java.time.Duration;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
public class CompleteNavigationTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
try {
driver.manage().window().maximize();
driver.get("https://www.google.com");
System.out.println(
"Title: " + driver.getTitle()
);
System.out.println(
"URL: " + driver.getCurrentUrl()
);
driver.navigate().to(
"https://www.selenium.dev"
);
System.out.println(
"Title: " + driver.getTitle()
);
System.out.println(
"URL: " + driver.getCurrentUrl()
);
driver.navigate().back();
System.out.println(
"After Back: " + driver.getCurrentUrl()
);
driver.navigate().forward();
System.out.println(
"After Forward: " + driver.getCurrentUrl()
);
driver.navigate().refresh();
System.out.println(
"After Refresh: " + driver.getCurrentUrl()
);
} finally {
driver.quit();
}
}
}
In this practical project, we will create a Selenium test that opens a website, checks the title and URL, performs browser navigation, and validates the resulting page.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class BrowserNavigationProject {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
System.out.println("Opening Selenium website...");
driver.get("https://www.selenium.dev");
System.out.println(
"Current Title: " + driver.getTitle()
);
System.out.println(
"Current URL: " + driver.getCurrentUrl()
);
System.out.println("Opening another page...");
driver.navigate().to(
"https://www.selenium.dev/documentation/"
);
System.out.println(
"Current URL: " + driver.getCurrentUrl()
);
System.out.println("Going back...");
driver.navigate().back();
System.out.println(
"Current URL: " + driver.getCurrentUrl()
);
System.out.println("Going forward...");
driver.navigate().forward();
System.out.println(
"Current URL: " + driver.getCurrentUrl()
);
System.out.println("Refreshing page...");
driver.navigate().refresh();
System.out.println(
"Page refreshed successfully"
);
} finally {
driver.quit();
System.out.println(
"Browser closed"
);
}
}
}
In a professional automation framework, navigation is usually separated into reusable components.
Automation Framework
|
+-- Driver Management
|
+-- Configuration
|
+-- Page Objects
|
+-- Tests
|
+-- Utilities
|
+-- Reports
|
+-- Screenshots
The navigation responsibility can be placed inside page objects or reusable navigation utilities depending on the framework architecture.
A Page Object can expose methods that represent meaningful application navigation.
public class HomePage {
private WebDriver driver;
public HomePage(WebDriver driver) {
this.driver = driver;
}
public void open() {
driver.get("https://example.com");
}
public void openLogin() {
driver.get("https://example.com/login");
}
public String getCurrentUrl() {
return driver.getCurrentUrl();
}
}
The test can then use:
HomePage homePage = new HomePage(driver);
homePage.open();
homePage.openLogin();
Navigation becomes more useful when combined with assertions.
driver.get("https://example.com/login");
Assert.assertEquals(
driver.getCurrentUrl(),
"https://example.com/login"
);
Assert.assertTrue(
driver.getTitle().contains("Login")
);
Navigate
↓
Read Current URL
↓
Compare Expected URL
↓
Read Title
↓
Compare Expected Title
↓
Pass / Fail
Direct URL access means explicitly instructing WebDriver to open a destination.
driver.get("https://example.com/products");Browser navigation through application controls means allowing the application itself to determine the next destination.
driver.findElement(By.linkText("Products")).click();Both approaches are useful, but they test different aspects of the application.
Test Case
↓
Page Object
↓
Navigation Method
↓
WebDriver
↓
Browser Driver
↓
Browser
↓
Web Application
The test describes what should happen, the page object can provide reusable navigation behavior, and WebDriver communicates the browser operation.
Modern Selenium releases include Selenium Manager to assist with browser-driver management in common setups. This can reduce the need for manually managing driver executable paths in many cases.
A basic Selenium 4 setup can therefore look like:
WebDriver driver = new ChromeDriver();
driver.get("https://www.selenium.dev");
The important point for browser navigation is that a valid WebDriver session must exist before navigation commands are executed.
Answer: A URL can be opened using the driver.get() method.
driver.get("https://www.google.com");Another option is:
driver.navigate().to("https://www.google.com");Answer: driver.get() is a WebDriver method used to navigate the current browser window or tab to a specified URL.
driver.get("https://example.com");Answer: Both can be used to navigate to a URL. driver.get() is the shorter and commonly used form, while driver.navigate().to() is part of the navigation interface that also provides methods such as back(), forward(), and refresh().
Answer: Selenium can navigate to URLs that the active browser session can access, provided the URL is valid and the browser/environment permits access.
driver.get("https://example.com");For HTTP/HTTPS URLs, the URL should include the appropriate protocol.
Answer: In Java Selenium, use driver.getCurrentUrl().
String currentUrl = driver.getCurrentUrl();
System.out.println(currentUrl);
This is commonly used for URL validation after navigation.
| Command | Purpose |
|---|---|
driver.get(url) |
Open a URL. |
driver.navigate().to(url) |
Navigate to a URL. |
driver.navigate().back() |
Go backward. |
driver.navigate().forward() |
Go forward. |
driver.navigate().refresh() |
Refresh the current page. |
driver.getCurrentUrl() |
Get current URL. |
driver.getTitle() |
Get current page title. |
driver.quit() |
Close the complete WebDriver session. |
Start Test
↓
Create WebDriver
↓
Launch Browser
↓
Open URL
↓
Read URL / Title
↓
Perform Page Actions
↓
Navigate to Another Page
↓
Back
↓
Forward
↓
Refresh
↓
Validate Result
↓
Take Screenshot if Required
↓
Close Browser
↓
End Test
After completing this topic, you should be able to:
driver.get().driver.navigate().to().For structured Selenium automation learning, you can explore the following JustAcademy resources:
Browser Navigation is a fundamental Selenium WebDriver concept used to control how the browser moves between web pages. Selenium provides driver.get() and driver.navigate().to() for opening URLs, while back(), forward(), and refresh() provide browser-history and reload operations.
A strong automation test should not only navigate to a page but should also validate that the expected page was reached. URL validation with getCurrentUrl(), title validation with getTitle(), explicit waits for dynamic content, and reusable Page Object navigation methods can make browser-navigation tests more reliable and maintainable.
The complete browser-navigation concept can be remembered as:
OPEN
↓
NAVIGATE
↓
BACK
↓
FORWARD
↓
REFRESH
↓
VALIDATE URL
↓
VALIDATE TITLE
↓
CONTINUE TEST
↓
QUIT
Understanding browser navigation provides the foundation for building larger Selenium automation workflows involving login, search, e-commerce, dashboards, multi-page applications, cross-browser testing, Page Object Model, TestNG, and complete end-to-end automation frameworks.
